/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.ufg.inf.si.poo.formula1.ManagementFiles;

import br.ufg.inf.si.poo.formula1.Circuit.Circuit;
import br.ufg.inf.si.poo.formula1.Driver.Driver;
import br.ufg.inf.si.poo.formula1.GUI.FrameMain;
import br.ufg.inf.si.poo.formula1.Library.Library;
import br.ufg.inf.si.poo.formula1.Race.Race;
import br.ufg.inf.si.poo.formula1.Season.Season;
import br.ufg.inf.si.poo.formula1.Team.Team;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * ManagementFilesSeason
 *
 * Versao 1.0
 *
 * Data 20/02/2013
 *
 * @author Igor
 */
public class ManagementFilesSeason {
    //Construtores

    private ManagementFilesSeason() {
    }

    //Outros Metodos
    /**
     * Reseta as configuracoes, dos Objetos, referentes aa temporada, ex.:
     * pilotos contratados, pontos dos pilotos...
     */
    public static void resetDataSeason() {
        //Pilotos
        for (int i = 0; i < FrameMain.getDrivers().size(); i++) {
            Driver driver = FrameMain.getDrivers().get(i);
            if (driver != null) {
                driver.setPoints(0);
                if (driver.getTeam() != null) {
                    driver.getTeam().dismissDriver(driver);
                }
            }
        }

        //Equipes
        for (int i = 0; i < FrameMain.getTeams().size(); i++) {
            Team team = FrameMain.getTeams().get(i);
            if (team != null) {
                team.setPoints(0);
                for (int j = 0; j < 4; j++) {
                    if (team.getDriver()[j] != null) {
                        team.dismissDriver(team.getDriver()[j]);
                    }
                }
            }
        }

        //Circuitos
        for (int i = 0; i < FrameMain.getCircuits().size(); i++) {
            Circuit circuits = FrameMain.getCircuits().get(i);
            if (circuits != null) {
                circuits.setRaceDate("");
            }
        }
    }

    /**
     * Realiza a leitura das equipes da temporadas no arquivo de equipes na
     * pasta referentes aa temporada
     *
     * @param season, lee no arquivo de equipe da temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void readTeamSeason(Season season, String folder) {
        String nome = "Equipes.txt";

        //Verifica se o arquivo existe
        File file = new File(folder + nome);
        if (file.exists()) {
            try {
                FileReader arq = new FileReader(folder + nome);
                BufferedReader lerArq = new BufferedReader(arq);

                /* Faz leitura das primeiras linhas que são as de configuração */
                String strShortName = lerArq.readLine();
                String strPoints = lerArq.readLine();
                String linha = lerArq.readLine();

                int intPoints = 0;

                while ((strShortName = lerArq.readLine()) != null) {
                    strPoints = lerArq.readLine();
                    intPoints = Integer.parseInt(strPoints);
                    Team team = Library.returnTeam(strShortName);
                    if (team != null) {
                        season.setTeams(team);
                        team.setPoints(intPoints);
                    }
                }

                arq.close();
            } catch (IOException e) {
                System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
            }
        }
    }

    /**
     * Realiza a escrita das equipes da temporadas no arquivo de equipes na
     * pasta referentes aa temporada
     *
     * @param season, escreve no arquivo de equipe da temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void writeTeamSeason(Season season, String folder) {
        String nome = "Equipes.txt";

        try {
            FileWriter arq = new FileWriter(folder + nome);
            PrintWriter escreverArq = new PrintWriter(arq);

            /* Faz escrita das primeiras linhas que são as de configuração */
            escreverArq.println("Short Name");
            escreverArq.println("Points");
            escreverArq.println("************");

            for (int i = 0; i < season.getQttTeams(); i++) {
                Team team = season.getTeams()[i];
                if (team != null) {
                    escreverArq.println(team.getShortName());
                    escreverArq.println(team.getPoints());
                }
            }

            arq.close();
        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    /**
     * Realiza a leitura das circuitos da temporadas no arquivo de circuitos na
     * pasta referentes aa temporada
     *
     * @param season, lee no arquivo de circuito da temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void readCircuitSeason(Season season, String folder) {
        String nome = "Circuitos.txt";

        //Verifica se o arquivo existe
        File file = new File(folder + nome);
        if (file.exists()) {
            try {
                FileReader arq = new FileReader(folder + nome);
                BufferedReader lerArq = new BufferedReader(arq);

                /* Faz leitura das primeiras linhas que são as de configuração */
                String strCountry = lerArq.readLine();
                String linha = lerArq.readLine();

                while ((strCountry = lerArq.readLine()) != null) {

                    Circuit circuit = Library.returnCircuit(strCountry);
                    if (circuit != null) {
                        season.setCircuits(circuit);
                    }
                }

                arq.close();
            } catch (IOException e) {
                System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
            }
        }
    }

    /**
     * Realiza a escrita dos circuitos da temporadas no arquivo de circuitos na
     * pasta referentes aa temporada
     *
     * @param season, escreve no arquivo de circuito da temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void writeCircuitSeason(Season season, String folder) {
        String nome = "Circuitos.txt";

        try {
            FileWriter arq = new FileWriter(folder + nome);
            PrintWriter escreverArq = new PrintWriter(arq);

            /* Faz escrita das primeiras linhas que são as de configuração */
            escreverArq.println("Country");
            escreverArq.println("************");

            for (int i = 0; i < season.getQttCircuits(); i++) {
                Circuit circuit = season.getCircuits()[i];
                if (circuit != null) {
                    escreverArq.println(circuit.getCountry());
                }
            }

            arq.close();
        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    /**
     * Realiza a leitura do arquivo de pilotos e equipes que sao relacionados
     */
    public static void readHireDriverSeason(Season season, String folder) {
        String nome = "PilotosEquipes.txt";

        File file = new File(folder + nome);
        if (file.exists()) {
            try {
                FileReader arq = new FileReader(folder + nome);
                BufferedReader lerArq = new BufferedReader(arq);

                /* Faz leitura das primeiras linhas que são as de configuração */
                String teamName = lerArq.readLine();
                String driverName = lerArq.readLine();
                String strPoints = lerArq.readLine();
                String linha = lerArq.readLine();

                int intPoints = 0;

                while ((teamName = lerArq.readLine()) != null) {
                    driverName = lerArq.readLine();
                    strPoints = lerArq.readLine();
                    intPoints = Integer.parseInt(strPoints);

                    Team team = Library.returnTeam(teamName);
                    if (team != null) {
                        Driver driver = Library.returnDriver(driverName);
                        if (driver != null) {
                            season.setDriver(driver);
                            team.hireDriver(driver);
                            driver.setPoints(intPoints);
                        }
                    }
                }
            } catch (IOException e) {
                System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
            }
        }
    }

    /**
     * Escreve o arquivo de pilotos e equipes que sao relacionados
     *
     * @param season temporada com todas equipes do sistema
     * @param folder local a ser gravado o arquivo, pois existe um por temporada
     */
    public static void writeHireDriverSeason(Season season, String folder) {
        String nome = "PilotosEquipes.txt";

        try {
            FileWriter arq = new FileWriter(folder + nome);
            PrintWriter escreverArq = new PrintWriter(arq);

            /* Faz escrita das primeiras linhas que são as de configuração */
            escreverArq.println("Team Short Name");
            escreverArq.println("Driver Name");
            escreverArq.println("Points");
            escreverArq.println("************");

            //Percorre todas equipes da temporada
            for (int i = 0; i < season.getQttTeams(); i++) {
                Team team = season.getTeams()[i];
                if (team != null) {
                    //Percorre todos pilotos da Equipe
                    for (int j = 0; j < 4; j++) {
                        if (team.getDriver()[j] != null) {
                            escreverArq.println(team.getShortName());
                            escreverArq.println(team.getDriver()[j].getDriverName());
                            escreverArq.println(team.getDriver()[j].getPoints());
                        }
                    }
                }
            }

            arq.close();
        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    public static void createRaceSeason(Season season) {
        if (season != null) {
            for (int i = 0; i < season.getQttCircuits(); i++) {
                Circuit circuit = season.getCircuits()[i];
                if (circuit != null) {
                    Race race = season.getRace()[i];
                    if (race == null) {
                        race = new Race(circuit, season.getYear());
                        //race.getCircuit().setRaceDate("");
                    }
                    season.setRace(race);
                }
            }
        }
    }

    /**
     * Realiza a escrita das corridas da temporadas no arquivo de corridas na
     * pasta referentes aas corridas da temporada
     *
     * @param season, escreve no arquivo de corridas da temporada
     * @param folder, diretorio da pasta da corridas da temporada
     */
    public static void writeRaceSeason(Season season, String folder) {
        String nome = "Corrida.txt";

        try {
            for (int i = 0; i < season.getQttCircuits(); i++) {
                Race race = season.getRace()[i];
                if (race != null) {
                    //Se a corrida nao possui circuit, entao ela nao existe realmente
                    if (race.getCircuit() != null) {

                        //Cria a posta se nao existir
                        String folderRace = folder + "/Corridas/" + race.getCircuit().getCountry() + "/";
                        File pasta = new File(folderRace);
                        if (!pasta.exists()) {
                            File dir = new File(folderRace);
                            dir.mkdirs();
                        }

                        FileWriter arq = new FileWriter(folderRace + nome);
                        PrintWriter escreverArq = new PrintWriter(arq);

                        /* Faz escrita das primeiras linhas que são as de configuração */
                        escreverArq.println("Circuit Country");
                        escreverArq.println("Race Date");
                        escreverArq.println("Year");
                        escreverArq.println("Status");
                        for (int j = 0; j < 26; j++) {
                            escreverArq.println("Driver" + (j + 1));
                        }
                        escreverArq.println("************");

                        escreverArq.println(race.getCircuit().getCountry());
                        escreverArq.println(race.getCircuit().getRaceDate());
                        escreverArq.println(race.getYear());
                        escreverArq.println(race.getStatus());

                        //Escreve os pilotos da corrida
                        for (int j = 0; j < race.getQttDrivers(); j++) {
                            if (race.getDrivers()[j] != null) {
                                escreverArq.println(race.getDrivers()[j].getDriverName());
                            } else {
                                escreverArq.println("");
                            }
                        }

                        arq.close();
                    }
                }
            }

        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    /**
     * Realiza a leitura das corridas da temporadas do arquivo de corridas na
     * pasta referentes aas corridas da temporada
     *
     * @param season, Realiza a leitura do arquivo de corridas da temporada
     * @param folder, diretorio da pasta da corridas da temporada
     */
    public static Race readRaceSeason(Season season, String folder) {
        String nome = "Corrida.txt";
        Race race = null;

        try {
            for (int i = 0; i < season.getQttCircuits(); i++) {
                Circuit circuit = season.getCircuits()[i];
                if (circuit != null) {
                    String folderRace = folder + "/Corridas/" + circuit.getCountry() + "/";

                    //Verifica se o arquivo de texto
                    File file = new File(folderRace + nome);
                    if (file.exists()) {
                        FileReader arq = new FileReader(folderRace + nome);
                        BufferedReader lerArq = new BufferedReader(arq);

                        /* Faz leitura das primeiras linhas que são as de configuração */
                        String strCountry = lerArq.readLine();
                        String strRaceDate = lerArq.readLine();
                        String strYear = lerArq.readLine();
                        String strStatus = lerArq.readLine();
                        String strDriver = "";
                        for (int j = 0; j < 26; j++) {
                            strDriver = lerArq.readLine();
                        }
                        String linha = lerArq.readLine();

                        //Faz a leitura dos dados reais
                        strCountry = lerArq.readLine();
                        Circuit circuitRace = Library.returnCircuit(strCountry);

                        int intYear = 0;
                        int intStatus = 0;

                        //So cria a corrida se o circuito existir realmente
                        if (circuitRace != null) {
                            strRaceDate = lerArq.readLine();
                            strYear = lerArq.readLine();
                            intYear = Integer.parseInt(strYear);
                            race = new Race(circuitRace, intYear);
                            strStatus = lerArq.readLine();
                            intStatus = Integer.parseInt(strStatus);

                            race.setStatus(intStatus);
                            race.getCircuit().setRaceDate(strRaceDate);

                            while ((strDriver = lerArq.readLine()) != null) {
                                Driver driver = Library.returnDriver(strDriver);

                                //So adiciona o piloto se ele existir
                                if (driver != null) {
                                    race.setDrivers(driver);
                                }
                            }
                            season.setRace(race);
                            ManagementFilesRace.readQualificationRace(race, folder);
                            ManagementFilesRace.readGridRaceRace(race, folder);
                        }
                    }
                }
            }
        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
        return race;
    }

    /**
     * Realiza a leitura do campeonato mundial de pilotos
     *
     * @param season, realiza a leitura do arquivo campeonato de mundial de
     * pilotos da temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void readWorldChampionshipDrivers(Season season, String folder) {
        String nome = "WorldChampionshipDrivers.txt";

        try {

            //Verifica se o arquivo de texto
            File file = new File(folder + nome);
            if (file.exists()) {
                Driver[] worldChampion = new Driver[season.getQttDriver()];
                int i = 0;
                FileReader arq = new FileReader(folder + nome);
                BufferedReader lerArq = new BufferedReader(arq);

                /* Faz leitura das primeiras linhas que são as de configuração */
                String strDriverName = lerArq.readLine();
                String linha = lerArq.readLine();

                while ((strDriverName = lerArq.readLine()) != null) {
                    Driver driver = Library.returnDriver(strDriverName);

                    //So adiciona o piloto se ele existir
                    if (driver != null) {
                        if (i < season.getQttDriver()) {
                            worldChampion[i] = driver;
                            i++;
                        }
                    }
                }
                season.setDriverWorldChampion(worldChampion);
            }
        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    /**
     * Realiza a escrita do campeonato mundial de pilotos
     *
     * @param season, escreve no arquivo campeonato de mundial de pilotos da
     * temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void writeWorldChampionshipDrivers(Season season, String folder) {
        String nome = "WorldChampionshipDrivers.txt";

        try {
            Driver[] worldChampion = season.getDriverWorldChampion();
            if (worldChampion != null) {
                //Cria a posta se nao existir
                File pasta = new File(folder);
                if (!pasta.exists()) {
                    File dir = new File(folder);
                    dir.mkdirs();
                }

                FileWriter arq = new FileWriter(folder + nome);
                PrintWriter escreverArq = new PrintWriter(arq);

                /* Faz escrita das primeiras linhas que são as de configuração */
                escreverArq.println("Driver Name");
                escreverArq.println("************");


                for (int i = 0; i < season.getQttDriver(); i++) {
                    if (worldChampion[i] != null) {
                        escreverArq.println(worldChampion[i].getDriverName());
                    }
                }
                arq.close();
            }

        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    /**
     * Realiza a leitura do campeonato mundial de construtores
     *
     * @param season, realiza a leitura do arquivo campeonato de mundial de
     * construtores da temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void readWorldChampionshipBuilders(Season season, String folder) {
        String nome = "WorldChampionshipBuilders.txt";

        try {

            //Verifica se o arquivo de texto
            File file = new File(folder + nome);
            if (file.exists()) {
                Team[] worldChampion = new Team[season.getQttTeams()];
                int i = 0;
                FileReader arq = new FileReader(folder + nome);
                BufferedReader lerArq = new BufferedReader(arq);

                /* Faz leitura das primeiras linhas que são as de configuração */
                String strTeamName = lerArq.readLine();
                String linha = lerArq.readLine();

                while ((strTeamName = lerArq.readLine()) != null) {
                    Team team = Library.returnTeam(strTeamName);

                    //So adiciona o piloto se ele existir
                    if (team != null) {
                        if (i < season.getQttTeams()) {
                            worldChampion[i] = team;
                            i++;
                        }
                    }
                }
                season.setTeamWorldChampionshipBuilders(worldChampion);
            }
        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }

    /**
     * Realiza a escrita do campeonato mundial de construtores
     *
     * @param season, escreve no arquivo campeonato de mundial de construtores da
     * temporada
     * @param folder, diretorio da pasta da temporada
     */
    public static void writeWorldChampionshipBuilders(Season season, String folder) {
        String nome = "WorldChampionshipBuilders.txt";

        try {
            Team[] worldChampion = season.getTeamWorldChampionshipBuilders();
            if (worldChampion != null) {
                //Cria a posta se nao existir
                File pasta = new File(folder);
                if (!pasta.exists()) {
                    File dir = new File(folder);
                    dir.mkdirs();
                }

                FileWriter arq = new FileWriter(folder + nome);
                PrintWriter escreverArq = new PrintWriter(arq);

                /* Faz escrita das primeiras linhas que são as de configuração */
                escreverArq.println("Team Name");
                escreverArq.println("************");


                for (int i = 0; i < season.getQttTeams(); i++) {
                    if (worldChampion[i] != null) {
                        escreverArq.println(worldChampion[i].getShortName());
                    }
                }
                arq.close();
            }

        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo: %s\nArquivo: %s\n", e.getMessage(), nome);
        }
    }
}
